package com.sg.service.biz.app.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.app.req.*;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.dto.integration.component.ImplementTwoValuesIsEqualityComReqDto;
import com.sg.dto.integration.component.ImplementTwoValuesIsEqualityComRespDto;
import com.sg.dto.integration.component.QueryClassMatchResultToAnswerDetailComReqDto;
import com.sg.dto.integration.component.QueryClassMatchResultToAnswerDetailComRespDto;
import com.sg.entity.OmsEvaluationObjectTargetCycle;
import com.sg.entity.OmsTargetObjective;
import com.sg.entity.OmsVirtualOrgMember;
import com.sg.entity.OmsVirtualOrgMemberDept;
import com.sg.service.base.app.*;
import com.sg.service.biz.app.*;
import com.sg.service.biz.app.nb.NbRefreshTree;
import com.sg.common.exception.Assert;
import com.wicket.okrcomponent.integration.ConfSchemeService;
import com.wicket.okrcomponent.integration.InterfaceModeService;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class RefreshTreeServiceImpl
        implements com.wicket.okrapp.biz.service.RefreshTreeService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
    @Resource
    private NbRefreshTree nbRefreshTree;
    //@Resource
    //private undefinedService undefinedService;
    @Resource
    private MOmsVirtualOrgMemberDeptService mOmsVirtualOrgMemberDeptService;
    @Resource
    private MOmsVirtualOrgMemberService mOmsVirtualOrgMemberService;
    @Resource
    private VirtualOrgService virtualOrgService;
    @Resource
    private TargetCycleService targetCycleService;
    @Resource
    private MOmsTargetObjectiveService mOmsTargetObjectiveService;
    @Resource
    private TimingTaskService timingTaskService;
    @Resource
    private IndexSystemService indexSystemService;
    @Resource
    private MOmsExecuteProgressService mOmsExecuteProgressService;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private WeightTargetService weightTargetService;
    @Resource
    private OffStateService offStateService;
    @Resource
    private MOmsTaskService mOmsTaskService;
//@Resource
    //private MCustomFields3Service mCustomFields3Service;

    /**
     * D3-分析生命周期新增/撤销存档操作类型(公共)[6593]
     * gen by moon at 5/29/2023, 4:49:50 AM
     */
    @Trace(operationName = "D3-分析生命周期新增/撤销存档操作类型(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAnalyseLifeCycleAddOpeTypeComRespDto implementAnalyseLifeCycleAddOpeTypeCom(ImplementAnalyseLifeCycleAddOpeTypeComReqDto reqDto) {


        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 = null;
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
//virtualUsage 3-3-09查被评对象目标周期详情  41138
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:925760_1_41138
        queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:925762_1_41138
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:925757_1_41138
            queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925758_1_41138
            queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925759_1_41138
            queryEvaObjTargetCycleDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:925761_1_41138
        }

        /*3-3-09查被评对象目标周期详情[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3-分析生命周期新增/撤销存档操作类型(公共)-3-3-09查被评对象目标周期详情-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3-分析生命周期新增/撤销存档操作类型(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(), "D3-分析生命周期新增/撤销存档操作类型(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(), "D3-分析生命周期新增/撤销存档操作类型(公共)-3-3-09查被评对象目标周期详情-是否父周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetId(), "D3-分析生命周期新增/撤销存档操作类型(公共)-3-3-09查被评对象目标周期详情-冗余目标ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3-分析生命周期新增/撤销存档操作类型(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;
        if ((omsEvaluationObjectTargetCycle == null)) {
            //if(3-3-09查被评对象目标周期详情.出参 值等于空 )  41141

            ImplementAnalyseEvaObjTableTypeCodeComRespDto implementAnalyseEvaObjTableTypeCodeComRespDto = null;
            ImplementAnalyseEvaObjTableTypeCodeComReqDto implementAnalyseEvaObjTableTypeCodeComReqDto = new ImplementAnalyseEvaObjTableTypeCodeComReqDto();
            if (reqDto != null) {
                implementAnalyseEvaObjTableTypeCodeComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:989260_1_43356
            }

            /*D3分析被评对象内容表类型编码(公共)[6991]   */
            Assert.isNull(implementAnalyseEvaObjTableTypeCodeComReqDto.getEvaObjTypeCode(), "D3-分析生命周期新增/撤销存档操作类型(公共)-D3分析被评对象内容表类型编码(公共)-被评对象类型编码不能为空", false);
            implementAnalyseEvaObjTableTypeCodeComRespDto = implementAnalyseEvaObjTableTypeCodeCom(implementAnalyseEvaObjTableTypeCodeComReqDto)/*vcase invoke 同服务,同domain*/;


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
            receptionServiceReq.setSubjectLifeCycleOpt("CREATE");//sourceId:925748_1_41142

            /*生命周期操作：新增[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getSubjectLifeCycleOpt(), "D3-分析生命周期新增/撤销存档操作类型(公共)-生命周期操作：新增-生命周期操作不能为空", false);
            receptionServiceRes = nbRefreshTree.calculateAcceptAboveFields(receptionServiceReq);


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            if (implementAnalyseEvaObjTableTypeCodeComRespDto != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
                if (receptionServiceRes != null) {
                    receptionServiceReq_1.setSubjectLifeCycleOpt(receptionServiceRes.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925731_1_41143
                }
                if (implementAnalyseEvaObjTableTypeCodeComRespDto != null) {
                    receptionServiceReq_1.setEvaObjTableTypeCode(implementAnalyseEvaObjTableTypeCodeComRespDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989263_1_41143
                }

                /*约定出参：生命周期操作[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getSubjectLifeCycleOpt(), "D3-分析生命周期新增/撤销存档操作类型(公共)-约定出参：生命周期操作-生命周期操作不能为空", false);
                receptionServiceRes_2 = nbRefreshTree.calculateAcceptAboveFields(receptionServiceReq_1);


                receptionServiceRes_3 = receptionServiceRes_2;
            }
        } else if ((omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsArchive() != null && omsEvaluationObjectTargetCycle.getIsArchive().equals("TRUE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getArchivngType() != null && omsEvaluationObjectTargetCycle.getArchivngType().equals("ARCHIVED") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getSubjectLifeCycle() != null && omsEvaluationObjectTargetCycle.getSubjectLifeCycle().equals("ARCHIVING"))) {
            //elseif((3-3-09查目标父周期是否存在.出参 值不等于空  and 3-3-09查目标父周期是否存在.是否存档 等于 是 and 3-3-09查目标父周期是否存在.存档类型 等于 已归档 and 3-3-09查目标父周期是否存在.主体生命周期 等于 历史存档))  41145

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
            receptionServiceReq_2.setSubjectLifeCycleOpt("UNDO_ARCHIVE");//sourceId:925754_1_41146

            /*生命周期操作：撤销存档[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getSubjectLifeCycleOpt(), "D3-分析生命周期新增/撤销存档操作类型(公共)-生命周期操作：撤销存档-生命周期操作不能为空", false);
            receptionServiceRes_4 = nbRefreshTree.calculateAcceptAboveFields(receptionServiceReq_2);


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
            if (omsEvaluationObjectTargetCycle != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
                if (receptionServiceRes_4 != null) {
                    receptionServiceReq_3.setSubjectLifeCycleOpt(receptionServiceRes_4.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925731_1_41147
                }
                if (omsEvaluationObjectTargetCycle != null) {
                    receptionServiceReq_3.setEvaObjTableTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989263_1_41147
                }

                /*约定出参：生命周期操作[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_3.getSubjectLifeCycleOpt(), "D3-分析生命周期新增/撤销存档操作类型(公共)-约定出参：生命周期操作-生命周期操作不能为空", false);
                receptionServiceRes_6 = nbRefreshTree.calculateAcceptAboveFields(receptionServiceReq_3);


                receptionServiceRes_3 = receptionServiceRes_6;
            }
        }
        ImplementAnalyseLifeCycleAddOpeTypeComRespDto retData = new ImplementAnalyseLifeCycleAddOpeTypeComRespDto();
        if (omsEvaluationObjectTargetCycle_1 != null) {
            retData.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:925786_1
            retData.setEvaObjEntityId(omsEvaluationObjectTargetCycle_1.getEvaObjEntityId());//SimpleFieldAssign//sourceId:925926_1
            retData.setEvaObjTypeCode(omsEvaluationObjectTargetCycle_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925928_1
            retData.setTargetCycleContentId(omsEvaluationObjectTargetCycle_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925929_1
            retData.setTargetCycleContentTypeCode(omsEvaluationObjectTargetCycle_1.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925930_1
        }
        if (receptionServiceRes_3 != null) {
            retData.setEvaObjTableTypeCode(receptionServiceRes_3.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989265_1
            retData.setSubjectLifeCycleOpt(receptionServiceRes_3.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925782_1
        }


        return retData;
    }

    /**
     * D3-执行构建部门目标任务书树(公共)[6595]
     * gen by moon at 5/11/2023, 8:48:00 PM
     */
    @Trace(operationName = "D3-执行构建部门目标任务书树(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCreateFlevelObjTaskDutyDeptComRespDto implementCreateFlevelObjTaskDutyDeptCom(ImplementCreateFlevelObjTaskDutyDeptComReqDto reqDto) {


        ImplementCreateFlevelObjTaskDutyDeptComRespDto retData = new ImplementCreateFlevelObjTaskDutyDeptComRespDto();


        return retData;
    }

    /**
     * D3执行新增或删除三棵树叶子节点(公共)[6572]
     * gen by moon at 3/19/2024, 11:57:51 AM
     */
    @Trace(operationName = "D3执行新增或删除三棵树叶子节点(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAddOrDelThreeTreeLeafComRespDto implementAddOrDelThreeTreeLeafCom(ImplementAddOrDelThreeTreeLeafComReqDto reqDto) {


        if ((reqDto != null && reqDto.getEvaObjTargetCycleList() != null && reqDto.getEvaObjTargetCycleList().size() > 0)) {
            //if(D3-执行更新三棵树叶子节点(公共).被评对象目标周期列表数据集条数 大于 0)  40975

//ModelCode: circulationCollections
            for (EvaObjTargetCycleDto circulationCollectionsRes : reqDto.getEvaObjTargetCycleList()) {

                ImplementAnalyseLifeCycleOpeTypeComRespDto implementAnalyseLifeCycleOpeTypeComRespDto = null;
                ImplementAnalyseLifeCycleOpeTypeComReqDto implementAnalyseLifeCycleOpeTypeComReqDto = new ImplementAnalyseLifeCycleOpeTypeComReqDto();
                if (circulationCollectionsRes != null) {
                    implementAnalyseLifeCycleOpeTypeComReqDto.setSubjectLifeCycle(circulationCollectionsRes.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:925382_1_41133
                }

                /*D3分析生命周期操作类型(公共)[6592]   */
                Assert.isNull(implementAnalyseLifeCycleOpeTypeComReqDto.getSubjectLifeCycle(), "D3执行新增或删除三棵树叶子节点(公共)-D3分析生命周期操作类型(公共)-主体生命周期不能为空", false);
                implementAnalyseLifeCycleOpeTypeComRespDto = implementAnalyseLifeCycleOpeTypeCom(implementAnalyseLifeCycleOpeTypeComReqDto)/*vcase invoke 同服务,同domain*/;


                ImplementVirtualOrgOrVirtualOrgMemberComRespDto implementVirtualOrgOrVirtualOrgMemberComRespDto = null;
                ImplementVirtualOrgOrVirtualOrgMemberComReqDto implementVirtualOrgOrVirtualOrgMemberComReqDto = new ImplementVirtualOrgOrVirtualOrgMemberComReqDto();
                if (circulationCollectionsRes != null) {
                    implementVirtualOrgOrVirtualOrgMemberComReqDto.setEvaObjEntityId(circulationCollectionsRes.getEvaObjEntityId());//SimpleFieldAssign//sourceId:923611_1_41012
                    implementVirtualOrgOrVirtualOrgMemberComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:921533_1_41012
                }
                if (reqDto != null) {
                    implementVirtualOrgOrVirtualOrgMemberComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:921530_1_41012
                }

                /*D3-执行虚拟组织或成员存在判断(公共)[6575]   */
                Assert.isNull(implementVirtualOrgOrVirtualOrgMemberComReqDto.getEvaObjEntityId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-执行虚拟组织或成员存在判断(公共)-被评对象内容表主键ID不能为空", false);
                Assert.isNull(implementVirtualOrgOrVirtualOrgMemberComReqDto.getEvaObjTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3-执行虚拟组织或成员存在判断(公共)-被评对象类型编码不能为空", false);
                Assert.isNull(implementVirtualOrgOrVirtualOrgMemberComReqDto.getTargetCycleContentId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-执行虚拟组织或成员存在判断(公共)-关联目标内容ID不能为空", false);
                implementVirtualOrgOrVirtualOrgMemberComRespDto = virtualOrgService.implementVirtualOrgOrVirtualOrgMemberCom(implementVirtualOrgOrVirtualOrgMemberComReqDto)/*vcase invoke isSameApp*/;


                if ((implementVirtualOrgOrVirtualOrgMemberComRespDto != null && implementVirtualOrgOrVirtualOrgMemberComRespDto.getTureOrFalse() != null && implementVirtualOrgOrVirtualOrgMemberComRespDto.getTureOrFalse().equals("FALSE")) && (reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT") || reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL") || reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT"))) {
                    //if(D3-执行虚拟组织或成员存在判断(公共).是否 等于 否 and (D3执行新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 OKR责任主体部门 or D3执行新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 OKR责任主体个人 or D3执行新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 一级部门目标任务责任部门))  41013

                    ImplementAnalyseThreeTreeLeafLifeOpeComRespDto implementAnalyseThreeTreeLeafLifeOpeComRespDto = null;
                    if (implementAnalyseLifeCycleOpeTypeComRespDto != null) {
                        ImplementAnalyseThreeTreeLeafLifeOpeComReqDto implementAnalyseThreeTreeLeafLifeOpeComReqDto = new ImplementAnalyseThreeTreeLeafLifeOpeComReqDto();
                        if (implementAnalyseLifeCycleOpeTypeComRespDto != null) {
                            implementAnalyseThreeTreeLeafLifeOpeComReqDto.setSubjectLifeCycleOpt(implementAnalyseLifeCycleOpeTypeComRespDto.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:926044_1_41165
                        }
                        if (circulationCollectionsRes != null) {
                            implementAnalyseThreeTreeLeafLifeOpeComReqDto.setEvaObjEntityId(circulationCollectionsRes.getEvaObjEntityId());//SimpleFieldAssign//sourceId:926040_1_41165
                            implementAnalyseThreeTreeLeafLifeOpeComReqDto.setEvaObjTableTypeCode(circulationCollectionsRes.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:926045_1_41165
                            implementAnalyseThreeTreeLeafLifeOpeComReqDto.setTargetCycleContentTypeCode("OBJECTIVE");//sourceId:926046_1_41165
                            implementAnalyseThreeTreeLeafLifeOpeComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:926042_1_41165
                        }
                        if (reqDto != null) {
                            implementAnalyseThreeTreeLeafLifeOpeComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:926041_1_41165
                            implementAnalyseThreeTreeLeafLifeOpeComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:926043_1_41165
                        }

                        /*D3执行分析三棵树叶子生命周期操作(公共)[6591]   */
                        Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getSubjectLifeCycleOpt(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-生命周期操作不能为空", false);
                        Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getEvaObjEntityId(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象内容表主键ID不能为空", false);
                        Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getEvaObjTableTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象内容表类型编码不能为空", false);
                        Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getEvaObjTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象类型编码不能为空", false);
                        Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getTargetCycleContentTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-关联目标内容类型编码不能为空", false);
                        Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getTargetCycleContentId(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-关联目标内容ID不能为空", false);
                        Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getTargetId(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-冗余目标ID不能为空", false);
                        implementAnalyseThreeTreeLeafLifeOpeComRespDto = implementAnalyseThreeTreeLeafLifeOpeCom(implementAnalyseThreeTreeLeafLifeOpeComReqDto)/*vcase invoke 同服务,同domain*/;


                    }
                }
//ModelCode: circulationEnd
            }

        }
        if ((reqDto != null && reqDto.getVirtualOrgMemberDeptList() != null && reqDto.getVirtualOrgMemberDeptList().size() > 0 || reqDto != null && reqDto.getVirtualOrgMemberList() != null && reqDto.getVirtualOrgMemberList().size() > 0)) {
            //if((D3-新增或删除三棵树叶子节点(公共).虚拟成员部门列表数据集条数 大于 0 or D3-新增或删除三棵树叶子节点(公共).虚拟组织成员列表数据集条数 大于 0))  40977

            if ((reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT") || reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT"))) {
                //if((D3-新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 OKR责任主体部门 or D3-新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 一级部门目标任务责任部门))  41102

//ModelCode: circulationCollections
                for (VirtualOrgMemberDeptDto circulationCollectionsRes_2 : reqDto.getVirtualOrgMemberDeptList()) {

                    ImplementAnalyseLifeCycleAddOpeTypeComRespDto implementAnalyseLifeCycleAddOpeTypeComRespDto = null;
                    ImplementAnalyseLifeCycleAddOpeTypeComReqDto implementAnalyseLifeCycleAddOpeTypeComReqDto = new ImplementAnalyseLifeCycleAddOpeTypeComReqDto();
                    if (circulationCollectionsRes_2 != null) {
                        implementAnalyseLifeCycleAddOpeTypeComReqDto.setEvaObjEntityId(circulationCollectionsRes_2.getEntityId());//SimpleFieldAssign//sourceId:925804_1_41148
                        implementAnalyseLifeCycleAddOpeTypeComReqDto.setTargetCycleContentId(circulationCollectionsRes_2.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:925806_1_41148
                    }
                    if (reqDto != null) {
                        implementAnalyseLifeCycleAddOpeTypeComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925805_1_41148
                        implementAnalyseLifeCycleAddOpeTypeComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:925807_1_41148
                    }

                    /*D3-分析生命周期新增/撤销存档操作类型(公共)[6593]   */
                    Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto.getEvaObjEntityId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-被评对象内容表主键ID不能为空", false);
                    Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto.getEvaObjTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-被评对象类型编码不能为空", false);
                    Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto.getTargetCycleContentId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto.getTargetId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-冗余目标ID不能为空", false);
                    implementAnalyseLifeCycleAddOpeTypeComRespDto = implementAnalyseLifeCycleAddOpeTypeCom(implementAnalyseLifeCycleAddOpeTypeComReqDto)/*vcase invoke 同服务,同domain*/;


                    if ((implementAnalyseLifeCycleAddOpeTypeComRespDto != null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt() != null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt().equals("CREATE") && reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT") && !(implementAnalyseLifeCycleAddOpeTypeComRespDto != null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getTargetCycleContentTypeCode() != null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")))) {
                        //if((D3-分析生命周期操作类型（新增或撤销存档）.生命周期操作 等于 新增 and D3执行新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 OKR责任主体部门 and D3-分析生命周期操作类型（新增或撤销存档）.关联目标内容类型编码 不等于 目标分类))  41114

                        StructureOkrDeptCurrentSuperiorComRespDto structureOkrDeptCurrentSuperiorComRespDto = null;
                        if (implementAnalyseLifeCycleAddOpeTypeComRespDto != null) {
                            StructureOkrDeptCurrentSuperiorComReqDto structureOkrDeptCurrentSuperiorComReqDto = new StructureOkrDeptCurrentSuperiorComReqDto();
                            if (circulationCollectionsRes_2 != null) {
                                structureOkrDeptCurrentSuperiorComReqDto.setEvaObjEntityId(circulationCollectionsRes_2.getDeptId());//SimpleFieldAssign//sourceId:921584_1_41115
                                structureOkrDeptCurrentSuperiorComReqDto.setObjectiveId(circulationCollectionsRes_2.getEntityId());//SimpleFieldAssign//sourceId:921581_1_41115
                                structureOkrDeptCurrentSuperiorComReqDto.setBatchCode(circulationCollectionsRes_2.getBatchCode());//SimpleFieldAssign//sourceId:921583_1_41115
                            }
                            if (implementAnalyseLifeCycleAddOpeTypeComRespDto != null) {
                                structureOkrDeptCurrentSuperiorComReqDto.setEvaObjTableTypeCode(implementAnalyseLifeCycleAddOpeTypeComRespDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:921585_1_41115
                            }
                            if (reqDto != null) {
                                structureOkrDeptCurrentSuperiorComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:921586_1_41115
                                structureOkrDeptCurrentSuperiorComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:921582_1_41115
                            }

                            /*D3-3构建OKR部门当前与上级目标(公共)[3332]   */
                            Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto.getEvaObjEntityId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-被评对象内容表主键ID不能为空", false);
                            Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto.getEvaObjTableTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-被评对象内容表类型编码不能为空", false);
                            Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto.getEvaObjTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-被评对象类型编码不能为空", false);
                            Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto.getObjectiveId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-指标ID不能为空", false);
                            Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto.getTargetId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-冗余目标ID不能为空", false);
                            Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto.getBatchCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-批次标识不能为空", false);
                            structureOkrDeptCurrentSuperiorComRespDto = targetCycleService.structureOkrDeptCurrentSuperiorCom(structureOkrDeptCurrentSuperiorComReqDto)/*vcase invoke isSameApp*/;


                        }
                    } else if ((implementAnalyseLifeCycleAddOpeTypeComRespDto != null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt() != null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt().equals("CREATE") && reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT") && circulationCollectionsRes_2 != null && circulationCollectionsRes_2.getTableTypeCode() != null && circulationCollectionsRes_2.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
                        //elseif((D3-分析生命周期操作类型（新增或撤销存档）.生命周期操作 等于 新增 and D3执行新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 一级部门目标任务责任部门 and M3执行虚拟成员部门【循环开始】.冗余内容表类型编码 等于 指标表))  41120

                        ImplementCreateFlevelObjTaskTreeDeptComRespDto implementCreateFlevelObjTaskTreeDeptComRespDto = null;
                        ImplementCreateFlevelObjTaskTreeDeptComReqDto implementCreateFlevelObjTaskTreeDeptComReqDto = new ImplementCreateFlevelObjTaskTreeDeptComReqDto();
                        if (circulationCollectionsRes_2 != null) {
                            implementCreateFlevelObjTaskTreeDeptComReqDto.setEvaObjEntityId(circulationCollectionsRes_2.getDeptId());//SimpleFieldAssign//sourceId:926382_1_43581
                            implementCreateFlevelObjTaskTreeDeptComReqDto.setObjectiveId(circulationCollectionsRes_2.getEntityId());//SimpleFieldAssign//sourceId:926380_1_43581
                            implementCreateFlevelObjTaskTreeDeptComReqDto.setEvaluationTemplateId(circulationCollectionsRes_2.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:926381_1_43581
                        }

                        /*D3构建部门目标任务书树(公共)[6595]   */
                        Assert.isNull(implementCreateFlevelObjTaskTreeDeptComReqDto.getEvaObjEntityId(), "D3执行新增或删除三棵树叶子节点(公共)-D3构建部门目标任务书树(公共)-被评对象内容表主键ID不能为空", false);
                        Assert.isNull(implementCreateFlevelObjTaskTreeDeptComReqDto.getObjectiveId(), "D3执行新增或删除三棵树叶子节点(公共)-D3构建部门目标任务书树(公共)-指标ID不能为空", false);
                        Assert.isNull(implementCreateFlevelObjTaskTreeDeptComReqDto.getEvaluationTemplateId(), "D3执行新增或删除三棵树叶子节点(公共)-D3构建部门目标任务书树(公共)-冗余评价模板ID不能为空", false);
                        implementCreateFlevelObjTaskTreeDeptComRespDto = implementCreateFlevelObjTaskTreeDeptCom(implementCreateFlevelObjTaskTreeDeptComReqDto)/*vcase invoke 同服务,同domain*/;


                    } else if ((implementAnalyseLifeCycleAddOpeTypeComRespDto != null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt() != null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt().equals("UNDO_ARCHIVE") && !(implementAnalyseLifeCycleAddOpeTypeComRespDto != null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getTargetCycleContentTypeCode() != null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")))) {
                        //elseif((D3-分析生命周期操作类型（新增或撤销存档）.生命周期操作 等于 撤销存档 and D3-分析生命周期操作类型（新增或撤销存档）.关联目标内容类型编码 不等于 目标分类))  41151

                        ImplementAnalyseThreeTreeLeafLifeOpeComRespDto implementAnalyseThreeTreeLeafLifeOpeComRespDto_1 = null;
                        if (implementAnalyseLifeCycleAddOpeTypeComRespDto != null) {
                            ImplementAnalyseThreeTreeLeafLifeOpeComReqDto implementAnalyseThreeTreeLeafLifeOpeComReqDto_1 = new ImplementAnalyseThreeTreeLeafLifeOpeComReqDto();
                            implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setTargetCycleContentTypeCode("OBJECTIVE");//sourceId:926046_1_41176
                            if (implementAnalyseLifeCycleAddOpeTypeComRespDto != null) {
                                implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setSubjectLifeCycleOpt(implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:926044_1_41176
                                implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setEvaObjTableTypeCode(implementAnalyseLifeCycleAddOpeTypeComRespDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:926045_1_41176
                            }
                            if (circulationCollectionsRes_2 != null) {
                                implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setEvaObjEntityId(circulationCollectionsRes_2.getDeptId());//SimpleFieldAssign//sourceId:926040_1_41176
                                implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setTargetCycleContentId(circulationCollectionsRes_2.getEntityId());//SimpleFieldAssign//sourceId:926042_1_41176
                            }
                            if (reqDto != null) {
                                implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:926041_1_41176
                                implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:926043_1_41176
                            }

                            /*D3执行分析三棵树叶子生命周期操作(公共)[6591]   */
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getSubjectLifeCycleOpt(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-生命周期操作不能为空", false);
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getEvaObjEntityId(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象内容表主键ID不能为空", false);
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getEvaObjTableTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象内容表类型编码不能为空", false);
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getEvaObjTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象类型编码不能为空", false);
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getTargetCycleContentTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-关联目标内容类型编码不能为空", false);
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getTargetCycleContentId(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-关联目标内容ID不能为空", false);
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getTargetId(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-冗余目标ID不能为空", false);
                            implementAnalyseThreeTreeLeafLifeOpeComRespDto_1 = implementAnalyseThreeTreeLeafLifeOpeCom(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1)/*vcase invoke 同服务,同domain*/;


                        }
                    }
//ModelCode: circulationEnd
                }

            } else if ((reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))) {
                //elseif(D3-新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 OKR责任主体个人)  41103

//ModelCode: circulationCollections
                for (VirtualOrgMemberDto circulationCollectionsRes_4 : reqDto.getVirtualOrgMemberList()) {

                    ImplementAnalyseLifeCycleAddOpeTypeComRespDto implementAnalyseLifeCycleAddOpeTypeComRespDto_2 = null;
                    ImplementAnalyseLifeCycleAddOpeTypeComReqDto implementAnalyseLifeCycleAddOpeTypeComReqDto_1 = new ImplementAnalyseLifeCycleAddOpeTypeComReqDto();
                    if (circulationCollectionsRes_4 != null) {
                        implementAnalyseLifeCycleAddOpeTypeComReqDto_1.setEvaObjEntityId(circulationCollectionsRes_4.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:925804_1_41177
                        implementAnalyseLifeCycleAddOpeTypeComReqDto_1.setTargetCycleContentId(circulationCollectionsRes_4.getEntityId());//SimpleFieldAssign//sourceId:925806_1_41177
                    }
                    if (reqDto != null) {
                        implementAnalyseLifeCycleAddOpeTypeComReqDto_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925805_1_41177
                        implementAnalyseLifeCycleAddOpeTypeComReqDto_1.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:925807_1_41177
                    }

                    /*D3-分析生命周期新增/撤销存档操作类型(公共)[6593]   */
                    Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto_1.getEvaObjEntityId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-被评对象内容表主键ID不能为空", false);
                    Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto_1.getEvaObjTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-被评对象类型编码不能为空", false);
                    Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto_1.getTargetCycleContentId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto_1.getTargetId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-冗余目标ID不能为空", false);
                    implementAnalyseLifeCycleAddOpeTypeComRespDto_2 = implementAnalyseLifeCycleAddOpeTypeCom(implementAnalyseLifeCycleAddOpeTypeComReqDto_1)/*vcase invoke 同服务,同domain*/;


                    if ((implementAnalyseLifeCycleAddOpeTypeComRespDto_2 != null && implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getEvaObjTargetCycleId() == null && circulationCollectionsRes_4 != null && circulationCollectionsRes_4.getTableTypeCode() != null && circulationCollectionsRes_4.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
                        //if((D3-分析生命周期操作类型（新增/撤销存档）.被评对象目标周期ID 值等于空  and M3执行虚拟组织成员【循环开始】.冗余内容表类型编码 等于 指标表))  41117

                        StructureOkrDeptCurrentSuperiorComRespDto structureOkrDeptCurrentSuperiorComRespDto_1 = null;
                        if (implementAnalyseLifeCycleAddOpeTypeComRespDto_2 != null) {
                            StructureOkrDeptCurrentSuperiorComReqDto structureOkrDeptCurrentSuperiorComReqDto_1 = new StructureOkrDeptCurrentSuperiorComReqDto();
                            if (circulationCollectionsRes_4 != null) {
                                structureOkrDeptCurrentSuperiorComReqDto_1.setEvaObjEntityId(circulationCollectionsRes_4.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:921584_1_41191
                                structureOkrDeptCurrentSuperiorComReqDto_1.setObjectiveId(circulationCollectionsRes_4.getEntityId());//SimpleFieldAssign//sourceId:921581_1_41191
                                structureOkrDeptCurrentSuperiorComReqDto_1.setBatchCode(circulationCollectionsRes_4.getBatchCode());//SimpleFieldAssign//sourceId:921583_1_41191
                            }
                            if (implementAnalyseLifeCycleAddOpeTypeComRespDto_2 != null) {
                                structureOkrDeptCurrentSuperiorComReqDto_1.setEvaObjTableTypeCode(implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:921585_1_41191
                            }
                            if (reqDto != null) {
                                structureOkrDeptCurrentSuperiorComReqDto_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:921586_1_41191
                                structureOkrDeptCurrentSuperiorComReqDto_1.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:921582_1_41191
                            }

                            /*D3-3构建OKR部门当前与上级目标(公共)[3332]   */
                            Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto_1.getEvaObjEntityId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-被评对象内容表主键ID不能为空", false);
                            Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto_1.getEvaObjTableTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-被评对象内容表类型编码不能为空", false);
                            Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto_1.getEvaObjTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-被评对象类型编码不能为空", false);
                            Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto_1.getObjectiveId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-指标ID不能为空", false);
                            Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto_1.getTargetId(), "D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-冗余目标ID不能为空", false);
                            Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto_1.getBatchCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-批次标识不能为空", false);
                            structureOkrDeptCurrentSuperiorComRespDto_1 = targetCycleService.structureOkrDeptCurrentSuperiorCom(structureOkrDeptCurrentSuperiorComReqDto_1)/*vcase invoke isSameApp*/;


                        }
                    } else if ((implementAnalyseLifeCycleAddOpeTypeComRespDto_2 != null && implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getEvaObjTargetCycleId() != null && implementAnalyseLifeCycleAddOpeTypeComRespDto_2 != null && implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getSubjectLifeCycleOpt() != null && implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getSubjectLifeCycleOpt().equals("UNDO_ARCHIVE") && !(implementAnalyseLifeCycleAddOpeTypeComRespDto_2 != null && implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getTargetCycleContentTypeCode() != null && implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")))) {
                        //elseif((D3-分析生命周期操作类型（新增/撤销存档）.被评对象目标周期ID 值不等于空  and D3-分析生命周期操作类型（新增/撤销存档）.生命周期操作 等于 撤销存档 and D3-分析生命周期操作类型（新增/撤销存档）.关联目标内容类型编码 不等于 目标分类))  41178

                        ImplementAnalyseThreeTreeLeafLifeOpeComRespDto implementAnalyseThreeTreeLeafLifeOpeComRespDto_2 = null;
                        if (implementAnalyseLifeCycleAddOpeTypeComRespDto_2 != null) {
                            ImplementAnalyseThreeTreeLeafLifeOpeComReqDto implementAnalyseThreeTreeLeafLifeOpeComReqDto_2 = new ImplementAnalyseThreeTreeLeafLifeOpeComReqDto();
                            implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setTargetCycleContentTypeCode("OBJECTIVE");//sourceId:926046_1_41179
                            if (implementAnalyseLifeCycleAddOpeTypeComRespDto_2 != null) {
                                implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setSubjectLifeCycleOpt(implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:926044_1_41179
                                implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setEvaObjTableTypeCode(implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:926045_1_41179
                            }
                            if (circulationCollectionsRes_4 != null) {
                                implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setEvaObjEntityId(circulationCollectionsRes_4.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:926040_1_41179
                                implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setTargetCycleContentId(circulationCollectionsRes_4.getEntityId());//SimpleFieldAssign//sourceId:926042_1_41179
                            }
                            if (reqDto != null) {
                                implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:926041_1_41179
                                implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:926043_1_41179
                            }

                            /*D3执行分析三棵树叶子生命周期操作(公共)[6591]   */
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getSubjectLifeCycleOpt(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-生命周期操作不能为空", false);
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getEvaObjEntityId(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象内容表主键ID不能为空", false);
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getEvaObjTableTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象内容表类型编码不能为空", false);
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getEvaObjTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象类型编码不能为空", false);
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getTargetCycleContentTypeCode(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-关联目标内容类型编码不能为空", false);
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getTargetCycleContentId(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-关联目标内容ID不能为空", false);
                            Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getTargetId(), "D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-冗余目标ID不能为空", false);
                            implementAnalyseThreeTreeLeafLifeOpeComRespDto_2 = implementAnalyseThreeTreeLeafLifeOpeCom(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2)/*vcase invoke 同服务,同domain*/;


                        }
                    }
//ModelCode: circulationEnd
                }

            }
        }
        ImplementAddOrDelThreeTreeLeafComRespDto retData = new ImplementAddOrDelThreeTreeLeafComRespDto();


        return retData;
    }

    /**
     * D3执行分析三棵树叶子生命周期操作(公共)[6591]
     * gen by moon at 5/11/2023, 8:48:43 PM
     */
    @Trace(operationName = "D3执行分析三棵树叶子生命周期操作(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAnalyseThreeTreeLeafLifeOpeComRespDto implementAnalyseThreeTreeLeafLifeOpeCom(ImplementAnalyseThreeTreeLeafLifeOpeComReqDto reqDto) {


        //virtualUsage 3-3-03查指标详情  41122
        OmsTargetObjective omsTargetObjective = null;
        QueryTargetObjDetailReq queryTargetObjDetailReq = new QueryTargetObjDetailReq();
        queryTargetObjDetailReq.setIsArchive("FALSE");//sourceId:924109_1_41122
        if (reqDto != null) {
            queryTargetObjDetailReq.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:924107_1_41122
            queryTargetObjDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:924119_1_41122
        }

        /*3-3-03查指标详情[2697]   */
        Assert.isNull(queryTargetObjDetailReq.getObjectiveId(), "D3执行分析三棵树叶子生命周期操作(公共)-3-3-03查指标详情-指标ID不能为空", false);
        Assert.isNull(queryTargetObjDetailReq.getTargetId(), "D3执行分析三棵树叶子生命周期操作(公共)-3-3-03查指标详情-冗余目标ID不能为空", false);
        Assert.isNull(queryTargetObjDetailReq.getIsArchive(), "D3执行分析三棵树叶子生命周期操作(公共)-3-3-03查指标详情-是否存档不能为空", false);
        omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((reqDto != null && reqDto.getSubjectLifeCycleOpt() != null && reqDto.getSubjectLifeCycleOpt().equals("DELETE"))) {
            //if(D3执行分析三棵树叶子生命周期操作(公共).生命周期操作 等于 删除)  41131

            if ((reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT") || reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))) {
                //if((D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 OKR责任主体部门 or D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 OKR责任主体个人))  41136

                DeleteOkrTreeTargetCycleComRespDto deleteOkrTreeTargetCycleComRespDto = null;
                DeleteOkrTreeTargetCycleComReqDto deleteOkrTreeTargetCycleComReqDto = new DeleteOkrTreeTargetCycleComReqDto();
                if (reqDto != null) {
                    deleteOkrTreeTargetCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1627979_1_41137
                    deleteOkrTreeTargetCycleComReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:925733_1_41137
                    deleteOkrTreeTargetCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925734_1_41137
                    deleteOkrTreeTargetCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925737_1_41137
                    deleteOkrTreeTargetCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925736_1_41137
                    deleteOkrTreeTargetCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:925735_1_41137
                }

                /*D3删除OKR树目标周期(公共)[3248]   */
                Assert.isNull(deleteOkrTreeTargetCycleComReqDto.getEvaObjEntityId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3删除OKR树目标周期(公共)-部门或身份人员ID不能为空", false);
                Assert.isNull(deleteOkrTreeTargetCycleComReqDto.getEvaObjTableTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3删除OKR树目标周期(公共)-被评对象内容表类型编码不能为空", false);
                Assert.isNull(deleteOkrTreeTargetCycleComReqDto.getEvaObjTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3删除OKR树目标周期(公共)-被评对象类型编码不能为空", false);
                Assert.isNull(deleteOkrTreeTargetCycleComReqDto.getTargetCycleContentTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3删除OKR树目标周期(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(deleteOkrTreeTargetCycleComReqDto.getTargetCycleContentId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3删除OKR树目标周期(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(deleteOkrTreeTargetCycleComReqDto.getTargetId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3删除OKR树目标周期(公共)-冗余目标ID不能为空", false);
                deleteOkrTreeTargetCycleComRespDto = timingTaskService.deleteOkrTreeTargetCycleCom(deleteOkrTreeTargetCycleComReqDto)/*vcase invoke isSameApp*/;


            } else if ((reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT"))) {
                //elseif(D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 一级部门目标任务责任部门)  41139

                LifecycleActionsDeptObjTreeAncestorsLeavesComRespDto lifecycleActionsDeptObjTreeAncestorsLeavesComRespDto = null;
                if (omsTargetObjective != null) {
                    LifecycleActionsDeptObjTreeAncestorsLeavesComReqDto lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto = new LifecycleActionsDeptObjTreeAncestorsLeavesComReqDto();
                    lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setTableTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:925770_1_41140
                    lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:925771_1_41140
                    if (reqDto != null) {
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setLifecyCycleOperationType(reqDto.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925767_1_41140
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925768_1_41140
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925769_1_41140
                    }
                    if (omsTargetObjective != null) {
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setLevelNumber(omsTargetObjective.getLevelNumber());//SimpleFieldAssign//sourceId:925772_1_41140
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setParentObjectiveId(omsTargetObjective.getParentObjectiveId());//SimpleFieldAssign//sourceId:925773_1_41140
                    }

                    /*D3执行生命周期操作部门目标任务书祖先叶子(公共)[5183]   */
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.getLifecyCycleOperationType(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-生命周期操作类型不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.getTargetCycleContentTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-关联目标内容类型编码不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.getTargetCycleContentId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.getTableTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-冗余内容表类型编码不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.getLevelNumber(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-层级不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.getSpaceId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-创建于空间ID不能为空", false);
                    lifecycleActionsDeptObjTreeAncestorsLeavesComRespDto = timingTaskService.lifecycleActionsDeptObjTreeAncestorsLeavesCom(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto)/*vcase invoke isSameApp*/;


                }
            }
        } else if ((reqDto != null && reqDto.getSubjectLifeCycleOpt() != null && reqDto.getSubjectLifeCycleOpt().equals("ARCHIVE"))) {
            //elseif(D3执行分析三棵树叶子生命周期操作(公共).生命周期操作 等于 存档)  41132

            if ((reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT") || reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))) {
                //if((D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 OKR责任主体部门 or D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 OKR责任主体个人))  41153

                ArchiveOkrTreeTargetCycleComRespDto archiveOkrTreeTargetCycleComRespDto = null;
                ArchiveOkrTreeTargetCycleComReqDto archiveOkrTreeTargetCycleComReqDto = new ArchiveOkrTreeTargetCycleComReqDto();
                archiveOkrTreeTargetCycleComReqDto.setTreeTypeCode("DUTY_SUBJECT");//sourceId:925817_1_41154
                if (reqDto != null) {
                    archiveOkrTreeTargetCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:925814_1_41154
                    archiveOkrTreeTargetCycleComReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:925815_1_41154
                    archiveOkrTreeTargetCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925816_1_41154
                    archiveOkrTreeTargetCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925818_1_41154
                    archiveOkrTreeTargetCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925819_1_41154
                    archiveOkrTreeTargetCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:925820_1_41154
                }

                /*D3存档OKR树目标周期(公共)[4153]   */
                Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getEvaObjEntityId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-被评对象内容表主键ID不能为空", false);
                Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getEvaObjTableTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-被评对象内容表类型编码不能为空", false);
                Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getEvaObjTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-被评对象类型编码不能为空", false);
                Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getTreeTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-树类型编码不能为空", false);
                Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getTargetCycleContentTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getTargetCycleContentId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getTargetId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-冗余目标ID不能为空", false);
                archiveOkrTreeTargetCycleComRespDto = timingTaskService.archiveOkrTreeTargetCycleCom(archiveOkrTreeTargetCycleComReqDto)/*vcase invoke isSameApp*/;


            } else if ((reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT"))) {
                //elseif(D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 一级部门目标任务责任部门)  41162

                LifecycleActionsDeptObjTreeAncestorsLeavesComRespDto lifecycleActionsDeptObjTreeAncestorsLeavesComRespDto_1 = null;
                if (omsTargetObjective != null) {
                    LifecycleActionsDeptObjTreeAncestorsLeavesComReqDto lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1 = new LifecycleActionsDeptObjTreeAncestorsLeavesComReqDto();
                    lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setTableTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:925770_1_41163
                    lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:925771_1_41163
                    if (reqDto != null) {
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setLifecyCycleOperationType(reqDto.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925767_1_41163
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925768_1_41163
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925769_1_41163
                    }
                    if (omsTargetObjective != null) {
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setLevelNumber(omsTargetObjective.getLevelNumber());//SimpleFieldAssign//sourceId:925772_1_41163
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setParentObjectiveId(omsTargetObjective.getParentObjectiveId());//SimpleFieldAssign//sourceId:925773_1_41163
                    }

                    /*D3执行生命周期操作部门目标任务书祖先叶子(公共)[5183]   */
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.getLifecyCycleOperationType(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-生命周期操作类型不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.getTargetCycleContentTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-关联目标内容类型编码不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.getTargetCycleContentId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.getTableTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-冗余内容表类型编码不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.getLevelNumber(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-层级不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.getSpaceId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-创建于空间ID不能为空", false);
                    lifecycleActionsDeptObjTreeAncestorsLeavesComRespDto_1 = timingTaskService.lifecycleActionsDeptObjTreeAncestorsLeavesCom(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1)/*vcase invoke isSameApp*/;


                }
            }
        } else if ((reqDto != null && reqDto.getSubjectLifeCycleOpt() != null && reqDto.getSubjectLifeCycleOpt().equals("UNDO_ARCHIVE"))) {
            //elseif(D3执行分析三棵树叶子生命周期操作(公共).生命周期操作 等于 撤销存档)  41134

            if ((reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT") || reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))) {
                //if((D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 OKR责任主体部门 or D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 OKR责任主体个人))  41157

                UndoToArchiveOkrTreeTargetCycleComRespDto undoToArchiveOkrTreeTargetCycleComRespDto = null;
                UndoToArchiveOkrTreeTargetCycleComReqDto undoToArchiveOkrTreeTargetCycleComReqDto = new UndoToArchiveOkrTreeTargetCycleComReqDto();
                undoToArchiveOkrTreeTargetCycleComReqDto.setTreeTypeCode("DUTY_SUBJECT");//sourceId:925914_1_41158
                if (reqDto != null) {
                    undoToArchiveOkrTreeTargetCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:925911_1_41158
                    undoToArchiveOkrTreeTargetCycleComReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:925912_1_41158
                    undoToArchiveOkrTreeTargetCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925913_1_41158
                    undoToArchiveOkrTreeTargetCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925915_1_41158
                    undoToArchiveOkrTreeTargetCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925916_1_41158
                    undoToArchiveOkrTreeTargetCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:925917_1_41158
                }

                /*D3撤销想存档OKR树目标周期(公共)[5077]   */
                Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getEvaObjEntityId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-被评对象内容表主键ID不能为空", false);
                Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getEvaObjTableTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-被评对象内容表类型编码不能为空", false);
                Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getEvaObjTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-被评对象类型编码不能为空", false);
                Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getTreeTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-树类型编码不能为空", false);
                Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getTargetCycleContentTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getTargetCycleContentId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getTargetId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-冗余目标ID不能为空", false);
                undoToArchiveOkrTreeTargetCycleComRespDto = timingTaskService.undoToArchiveOkrTreeTargetCycleCom(undoToArchiveOkrTreeTargetCycleComReqDto)/*vcase invoke isSameApp*/;


            } else if ((reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT"))) {
                //elseif(D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 一级部门目标任务责任部门)  41160

                LifecycleActionsDeptObjTreeAncestorsLeavesComRespDto lifecycleActionsDeptObjTreeAncestorsLeavesComRespDto_2 = null;
                if (omsTargetObjective != null) {
                    LifecycleActionsDeptObjTreeAncestorsLeavesComReqDto lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2 = new LifecycleActionsDeptObjTreeAncestorsLeavesComReqDto();
                    lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setTableTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:925770_1_41161
                    lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:925771_1_41161
                    if (reqDto != null) {
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setLifecyCycleOperationType(reqDto.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925767_1_41161
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925768_1_41161
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925769_1_41161
                    }
                    if (omsTargetObjective != null) {
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setLevelNumber(omsTargetObjective.getLevelNumber());//SimpleFieldAssign//sourceId:925772_1_41161
                        lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setParentObjectiveId(omsTargetObjective.getParentObjectiveId());//SimpleFieldAssign//sourceId:925773_1_41161
                    }

                    /*D3执行生命周期操作部门目标任务书祖先叶子(公共)[5183]   */
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.getLifecyCycleOperationType(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-生命周期操作类型不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.getTargetCycleContentTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-关联目标内容类型编码不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.getTargetCycleContentId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.getTableTypeCode(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-冗余内容表类型编码不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.getLevelNumber(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-层级不能为空", false);
                    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.getSpaceId(), "D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-创建于空间ID不能为空", false);
                    lifecycleActionsDeptObjTreeAncestorsLeavesComRespDto_2 = timingTaskService.lifecycleActionsDeptObjTreeAncestorsLeavesCom(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2)/*vcase invoke isSameApp*/;


                }
            }
        }
        ImplementAnalyseThreeTreeLeafLifeOpeComRespDto retData = new ImplementAnalyseThreeTreeLeafLifeOpeComRespDto();


        return retData;
    }

    /**
     * D3执行分析生命周期操作类型(公共)[6592]
     * gen by moon at 5/11/2023, 8:48:46 PM
     */
    @Trace(operationName = "D3执行分析生命周期操作类型(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAnalyseLifeCycleOpeTypeComRespDto implementAnalyseLifeCycleOpeTypeCom(ImplementAnalyseLifeCycleOpeTypeComReqDto reqDto) {


        ImplementAcceptFieldRespDto receptionServiceRes_3 = null;
        if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("EDITING"))) {
            //if(D3执行分析生命周期操作类型(公共).主体生命周期 等于 正在编辑)  41124

//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes = null;
            ImplementAcceptFieldReqDto receptionServiceReq = new ImplementAcceptFieldReqDto();
            receptionServiceReq.setSubjectLifeCycleOpt("DELETE");//sourceId:924809_1_41125

            /*M3生命周期操作类型：删除[6100]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getSubjectLifeCycleOpt(), "D3执行分析生命周期操作类型(公共)-M3生命周期操作类型：删除-生命周期操作不能为空", false);
            receptionServiceRes = nbRefreshTree.implementAcceptField(receptionServiceReq);


//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
            ImplementAcceptFieldReqDto receptionServiceReq_1 = new ImplementAcceptFieldReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setSubjectLifeCycleOpt(receptionServiceRes.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925270_1_41126
            }

            /*M3接收生命周期操作[6100]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getSubjectLifeCycleOpt(), "D3执行分析生命周期操作类型(公共)-M3接收生命周期操作-生命周期操作不能为空", false);
            receptionServiceRes_2 = nbRefreshTree.implementAcceptField(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))) {
            //elseif(D3执行分析生命周期操作类型(公共).主体生命周期 等于 当前有效)  41127

//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes_4 = null;
            ImplementAcceptFieldReqDto receptionServiceReq_2 = new ImplementAcceptFieldReqDto();
            receptionServiceReq_2.setSubjectLifeCycleOpt("ARCHIVE");//sourceId:924812_1_41128

            /*M3生命周期操作类型：存档[6100]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getSubjectLifeCycleOpt(), "D3执行分析生命周期操作类型(公共)-M3生命周期操作类型：存档-生命周期操作不能为空", false);
            receptionServiceRes_4 = nbRefreshTree.implementAcceptField(receptionServiceReq_2);


//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes_6 = null;
            ImplementAcceptFieldReqDto receptionServiceReq_3 = new ImplementAcceptFieldReqDto();
            if (receptionServiceRes_4 != null) {
                receptionServiceReq_3.setSubjectLifeCycleOpt(receptionServiceRes_4.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925270_1_41129
            }

            /*M3接收生命周期操作[6100]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getSubjectLifeCycleOpt(), "D3执行分析生命周期操作类型(公共)-M3接收生命周期操作-生命周期操作不能为空", false);
            receptionServiceRes_6 = nbRefreshTree.implementAcceptField(receptionServiceReq_3);


            receptionServiceRes_3 = receptionServiceRes_6;
        }
        ImplementAnalyseLifeCycleOpeTypeComRespDto retData = new ImplementAnalyseLifeCycleOpeTypeComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setSubjectLifeCycleOpt(receptionServiceRes_3.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925272_1
        }


        return retData;
    }

    /**
     * D3-执行三棵树树叶子节点存在性校验(公共)[6599]
     * gen by moon at 3/19/2024, 11:59:23 AM
     */
    @Trace(operationName = "D3-执行三棵树树叶子节点存在性校验(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCheckThreeTreeExistenceComRespDto implementCheckThreeTreeExistenceCom(ImplementCheckThreeTreeExistenceComReqDto reqDto) {


        OmsVirtualOrgMember omsVirtualOrgMember_1 = null;
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 = null;
        OmsVirtualOrgMemberDept omsVirtualOrgMemberDept_1 = null;
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_3 = null;
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_5 = null;
//virtualUsage 3-6-02查指标负责人是否存在  41211
        OmsVirtualOrgMember omsVirtualOrgMember = null;
        QueryVirtualOrgMemberDetailReq queryVirtualOrgMemberDetailReq = new QueryVirtualOrgMemberDetailReq();
        queryVirtualOrgMemberDetailReq.setIsPersonCharge("TRUE");//sourceId:1627967_1_41211
        queryVirtualOrgMemberDetailReq.setUseScene("TARGET_PLAN_SCENE");//sourceId:1627966_1_41211
        queryVirtualOrgMemberDetailReq.setIsArchive("FALSE");//sourceId:927466_1_41211
        if (reqDto != null) {
            queryVirtualOrgMemberDetailReq.setEntityId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:927467_1_41211
            queryVirtualOrgMemberDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:927468_1_41211
        }

        /*3-6-02查指标负责人是否存在[2379]   */
        Assert.isNull(queryVirtualOrgMemberDetailReq.getIsPersonCharge(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-6-02查指标负责人是否存在-是否负责人不能为空", false);
        Assert.isNull(queryVirtualOrgMemberDetailReq.getEntityId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-6-02查指标负责人是否存在-冗余内容表主键ID不能为空", false);
        Assert.isNull(queryVirtualOrgMemberDetailReq.getEvaluationTemplateId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-6-02查指标负责人是否存在-归属对象ID不能为空", false);
        Assert.isNull(queryVirtualOrgMemberDetailReq.getUseScene(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-6-02查指标负责人是否存在-虚拟组织使用场景不能为空", false);
        Assert.isNull(queryVirtualOrgMemberDetailReq.getIsArchive(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-6-02查指标负责人是否存在-是否存档不能为空", false);
        omsVirtualOrgMember = mOmsVirtualOrgMemberService.queryVirtualOrgMemberDetail(queryVirtualOrgMemberDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsVirtualOrgMember_1 = omsVirtualOrgMember;
//virtualUsage 3-3-09查OKR个人树根节点目标周期详情  41223
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        if (omsVirtualOrgMember != null) {
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("OKR_SUBJECT_PERSONAL");//sourceId:927133_1_41223
            queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:927135_1_41223
            queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:927137_1_41223
            if (omsVirtualOrgMember != null) {
                queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(omsVirtualOrgMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:927132_1_41223
            }
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:927134_1_41223
                queryEvaObjTargetCycleDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:927136_1_41223
            }

            /*3-3-09查OKR个人树根节点目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR个人树根节点目标周期详情-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR个人树根节点目标周期详情-被评对象类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR个人树根节点目标周期详情-关联目标内容ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR个人树根节点目标周期详情-是否父周期不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR个人树根节点目标周期详情-冗余目标ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR个人树根节点目标周期详情-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;
        }
        if ((reqDto != null && reqDto.getRespBodyType() != null && reqDto.getRespBodyType().equals("DEPT"))) {
            //if(D3-执行三棵树树叶子节点存在性校验(公共).责任主体类型 等于 部门)  41200

            OmsVirtualOrgMemberDept omsVirtualOrgMemberDept = null;
            ImplementUnrestraintQueryLeadDeptReq implementUnrestraintQueryLeadDeptReq = new ImplementUnrestraintQueryLeadDeptReq();
            implementUnrestraintQueryLeadDeptReq.setDeptType("LEAD_DEPT");//sourceId:927397_1_41216
            implementUnrestraintQueryLeadDeptReq.setTableTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:927398_1_41216
            implementUnrestraintQueryLeadDeptReq.setIsArchive("FALSE");//sourceId:927406_1_41216
            if (reqDto != null) {
                implementUnrestraintQueryLeadDeptReq.setEntityId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:927399_1_41216
                implementUnrestraintQueryLeadDeptReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:927408_1_41216
            }

            /*3-6-03执行无约束查牵头部门[3307]   */
            Assert.isNull(implementUnrestraintQueryLeadDeptReq.getDeptType(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-6-03执行无约束查牵头部门-部门类型编码不能为空", false);
            Assert.isNull(implementUnrestraintQueryLeadDeptReq.getTableTypeCode(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-6-03执行无约束查牵头部门-冗余内容表类型编码不能为空", false);
            Assert.isNull(implementUnrestraintQueryLeadDeptReq.getEntityId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-6-03执行无约束查牵头部门-冗余内容表主键ID不能为空", false);
            Assert.isNull(implementUnrestraintQueryLeadDeptReq.getEvaluationTemplateId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-6-03执行无约束查牵头部门-归属对象ID不能为空", false);
            Assert.isNull(implementUnrestraintQueryLeadDeptReq.getIsArchive(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-6-03执行无约束查牵头部门-是否存档不能为空", false);
            omsVirtualOrgMemberDept = mOmsVirtualOrgMemberDeptService.implementUnrestraintQueryLeadDept(implementUnrestraintQueryLeadDeptReq)/*vcase invoke 本地 method 方法调用;*/;


            omsVirtualOrgMemberDept_1 = omsVirtualOrgMemberDept;
            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
            if (omsVirtualOrgMemberDept != null) {
                QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1 = new QueryEvaObjTargetCycleDetailReq();
                queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode("OKR_SUBJECT_DEPT");//sourceId:927377_1_41203
                queryEvaObjTargetCycleDetailReq_1.setIsParentCycle("TRUE");//sourceId:927379_1_41203
                queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:927381_1_41203
                if (omsVirtualOrgMemberDept != null) {
                    queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(omsVirtualOrgMemberDept.getDeptId());//SimpleFieldAssign//sourceId:927376_1_41203
                }
                if (reqDto != null) {
                    queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:927378_1_41203
                    queryEvaObjTargetCycleDetailReq_1.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:927380_1_41203
                }

                /*3-3-09查OKR部门树目标周期详情[2313]   */
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR部门树目标周期详情-被评对象内容表主键ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR部门树目标周期详情-被评对象类型编码不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR部门树目标周期详情-关联目标内容ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsParentCycle(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR部门树目标周期详情-是否父周期不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR部门树目标周期详情-冗余目标ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR部门树目标周期详情-是否存档不能为空", false);
                omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                omsEvaluationObjectTargetCycle_3 = omsEvaluationObjectTargetCycle_2;
            }
            if ((reqDto != null && reqDto.getIsUseFirstDept() != null && reqDto.getIsUseFirstDept().equals("TRUE"))) {
                //if(D3-执行三棵树树叶子节点存在性校验(公共).是否用于一级部门 等于 是)  41202

                OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_4 = null;
                if (omsVirtualOrgMemberDept != null) {
                    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_2 = new QueryEvaObjTargetCycleDetailReq();
                    queryEvaObjTargetCycleDetailReq_2.setEvaObjTypeCode("FLEVEL_OBJ_TASK_DUTY_DEPT");//sourceId:927387_1_41204
                    queryEvaObjTargetCycleDetailReq_2.setIsParentCycle("TRUE");//sourceId:927389_1_41204
                    queryEvaObjTargetCycleDetailReq_2.setIsArchive("FALSE");//sourceId:927391_1_41204
                    if (omsVirtualOrgMemberDept != null) {
                        queryEvaObjTargetCycleDetailReq_2.setEvaObjEntityId(omsVirtualOrgMemberDept.getDeptId());//SimpleFieldAssign//sourceId:927386_1_41204
                    }
                    if (reqDto != null) {
                        queryEvaObjTargetCycleDetailReq_2.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:927388_1_41204
                        queryEvaObjTargetCycleDetailReq_2.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:927390_1_41204
                    }

                    /*3-3-09查部门目标任务书树目标周期详情[2313]   */
                    Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjEntityId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查部门目标任务书树目标周期详情-被评对象内容表主键ID不能为空", false);
                    Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTypeCode(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查部门目标任务书树目标周期详情-被评对象类型编码不能为空", false);
                    Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getTargetCycleContentId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查部门目标任务书树目标周期详情-关联目标内容ID不能为空", false);
                    Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getIsParentCycle(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查部门目标任务书树目标周期详情-是否父周期不能为空", false);
                    Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getTargetId(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查部门目标任务书树目标周期详情-冗余目标ID不能为空", false);
                    Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getIsArchive(), "D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查部门目标任务书树目标周期详情-是否存档不能为空", false);
                    omsEvaluationObjectTargetCycle_4 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


                    omsEvaluationObjectTargetCycle_5 = omsEvaluationObjectTargetCycle_4;
                }
            }
        }
        ImplementCheckThreeTreeExistenceComRespDto retData = new ImplementCheckThreeTreeExistenceComRespDto();
        if (omsVirtualOrgMemberDept_1 != null) {
            retData.setDeptId(omsVirtualOrgMemberDept_1.getDeptId());//SimpleFieldAssign//sourceId:927475_1
        }
        if (omsVirtualOrgMember_1 != null) {
            retData.setOriginalRoleMemberId(omsVirtualOrgMember_1.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1168031_1
        }
        if (omsEvaluationObjectTargetCycle_1 != null) {
            retData.setOkrPsEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:927477_1
        }
        if (omsEvaluationObjectTargetCycle_3 != null) {
            retData.setOkrDptEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_3.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:927478_1
        }
        if (omsEvaluationObjectTargetCycle_5 != null) {
            retData.setMLevelEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_5.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:927479_1
        }


        return retData;
    }

    /**
     * D3分析被评对象内容表类型编码(公共)[6991]
     * gen by moon at 5/30/2023, 3:16:06 PM
     */
    @Trace(operationName = "D3分析被评对象内容表类型编码(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAnalyseEvaObjTableTypeCodeComRespDto implementAnalyseEvaObjTableTypeCodeCom(ImplementAnalyseEvaObjTableTypeCodeComReqDto reqDto) {


        ImplementGainInParameterFieldsRespDto receptionServiceRes_3 = null;
        if ((reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("EVA_OBJECT"))) {
            //if(D3分析被评对象内容表类型编码(公共).被评对象类型编码 等于 评价对象)  43346

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq.setEvaObjTableTypeCode("OMS_FRAMEWORK_SPACE");//sourceId:989252_1_43350

            /*M3约定为：空间表[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getEvaObjTableTypeCode(), "D3分析被评对象内容表类型编码(公共)-M3约定为：空间表-被评对象内容表类型编码不能为空", false);
            receptionServiceRes = nbRefreshTree.implementGainInParameterFields(receptionServiceReq);


//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_2 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_1 = new ImplementGainInParameterFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setEvaObjTableTypeCode(receptionServiceRes.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989257_1_43351
            }

            /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getEvaObjTableTypeCode(), "D3分析被评对象内容表类型编码(公共)-M3接收上文出参值-被评对象内容表类型编码不能为空", false);
            receptionServiceRes_2 = nbRefreshTree.implementGainInParameterFields(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT") || reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT"))) {
            //elseif((D3分析被评对象内容表类型编码(公共).被评对象类型编码 等于 一级部门目标任务责任部门 or D3分析被评对象内容表类型编码(公共).被评对象类型编码 等于 OKR责任主体部门))  43347

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_4 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_2 = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq_2.setEvaObjTableTypeCode("OMS_ORG_DEPT");//sourceId:989254_1_43352

            /*M3约定为：部门表[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getEvaObjTableTypeCode(), "D3分析被评对象内容表类型编码(公共)-M3约定为：部门表-被评对象内容表类型编码不能为空", false);
            receptionServiceRes_4 = nbRefreshTree.implementGainInParameterFields(receptionServiceReq_2);


//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_6 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_3 = new ImplementGainInParameterFieldsReqDto();
            if (receptionServiceRes_4 != null) {
                receptionServiceReq_3.setEvaObjTableTypeCode(receptionServiceRes_4.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989257_1_43353
            }

            /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getEvaObjTableTypeCode(), "D3分析被评对象内容表类型编码(公共)-M3接收上文出参值-被评对象内容表类型编码不能为空", false);
            receptionServiceRes_6 = nbRefreshTree.implementGainInParameterFields(receptionServiceReq_3);


            receptionServiceRes_3 = receptionServiceRes_6;
        } else if ((reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))) {
            //elseif(D3分析被评对象内容表类型编码(公共).被评对象类型编码 等于 OKR责任主体个人)  43349

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_7 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_4 = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq_4.setEvaObjTableTypeCode("OMS_ORG_INDUCTION_RECORD");//sourceId:989255_1_43354

            /*M3约定为：就职记录表[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_4.getEvaObjTableTypeCode(), "D3分析被评对象内容表类型编码(公共)-M3约定为：就职记录表-被评对象内容表类型编码不能为空", false);
            receptionServiceRes_7 = nbRefreshTree.implementGainInParameterFields(receptionServiceReq_4);


//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_9 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_5 = new ImplementGainInParameterFieldsReqDto();
            if (receptionServiceRes_7 != null) {
                receptionServiceReq_5.setEvaObjTableTypeCode(receptionServiceRes_7.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989257_1_43355
            }

            /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_5.getEvaObjTableTypeCode(), "D3分析被评对象内容表类型编码(公共)-M3接收上文出参值-被评对象内容表类型编码不能为空", false);
            receptionServiceRes_9 = nbRefreshTree.implementGainInParameterFields(receptionServiceReq_5);


            receptionServiceRes_3 = receptionServiceRes_9;
        }
        ImplementAnalyseEvaObjTableTypeCodeComRespDto retData = new ImplementAnalyseEvaObjTableTypeCodeComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setEvaObjTableTypeCode(receptionServiceRes_3.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989259_1
        }


        return retData;
    }

    /**
     * D3构建部门目标任务书树(公共)[6595]
     * gen by moon at 10/9/2023, 1:15:27 AM
     */
    @Trace(operationName = "D3构建部门目标任务书树(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCreateFlevelObjTaskTreeDeptComRespDto implementCreateFlevelObjTaskTreeDeptCom(ImplementCreateFlevelObjTaskTreeDeptComReqDto reqDto) {


        //virtualUsage D3-查询指标公共详情(公共)  41166
        QueryComTargetObjDetailComRespDto queryComTargetObjDetailComRespDto = null;
        QueryComTargetObjDetailComReqDto queryComTargetObjDetailComReqDto = new QueryComTargetObjDetailComReqDto();
        if (reqDto != null) {
            queryComTargetObjDetailComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:926049_1_41166
            queryComTargetObjDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:926050_1_41166
        }

        /*D3-查询指标公共详情(公共)[5584]   */
        Assert.isNull(queryComTargetObjDetailComReqDto.getObjectiveId(), "D3构建部门目标任务书树(公共)-D3-查询指标公共详情(公共)-指标ID不能为空", false);
        Assert.isNull(queryComTargetObjDetailComReqDto.getEvaluationTemplateId(), "D3构建部门目标任务书树(公共)-D3-查询指标公共详情(公共)-冗余评价模板ID不能为空", false);
        queryComTargetObjDetailComRespDto = indexSystemService.queryComTargetObjDetailCom(queryComTargetObjDetailComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage D3-执行三棵树树叶子节点存在性校验(公共)  46749
        ImplementCheckThreeTreeExistenceComRespDto implementCheckThreeTreeExistenceComRespDto = null;
        if (queryComTargetObjDetailComRespDto != null) {
            ImplementCheckThreeTreeExistenceComReqDto implementCheckThreeTreeExistenceComReqDto = new ImplementCheckThreeTreeExistenceComReqDto();
            if (reqDto != null) {
                implementCheckThreeTreeExistenceComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1072669_1_46749
                implementCheckThreeTreeExistenceComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1072673_1_46749
            }
            if (queryComTargetObjDetailComRespDto != null) {
                implementCheckThreeTreeExistenceComReqDto.setRespBodyType(queryComTargetObjDetailComRespDto.getRespBodyType());//SimpleFieldAssign//sourceId:1072671_1_46749
                implementCheckThreeTreeExistenceComReqDto.setIsUseFirstDept(queryComTargetObjDetailComRespDto.getIsUseFirstDept());//SimpleFieldAssign//sourceId:1072672_1_46749
                implementCheckThreeTreeExistenceComReqDto.setTargetId(queryComTargetObjDetailComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1072670_1_46749
            }

            /*D3-执行三棵树树叶子节点存在性校验(公共)[6599]   */
            Assert.isNull(implementCheckThreeTreeExistenceComReqDto.getObjectiveId(), "D3构建部门目标任务书树(公共)-D3-执行三棵树树叶子节点存在性校验(公共)-指标ID不能为空", false);
            Assert.isNull(implementCheckThreeTreeExistenceComReqDto.getRespBodyType(), "D3构建部门目标任务书树(公共)-D3-执行三棵树树叶子节点存在性校验(公共)-责任主体类型不能为空", false);
            Assert.isNull(implementCheckThreeTreeExistenceComReqDto.getIsUseFirstDept(), "D3构建部门目标任务书树(公共)-D3-执行三棵树树叶子节点存在性校验(公共)-是否用于一级部门不能为空", false);
            Assert.isNull(implementCheckThreeTreeExistenceComReqDto.getTargetId(), "D3构建部门目标任务书树(公共)-D3-执行三棵树树叶子节点存在性校验(公共)-冗余目标ID不能为空", false);
            Assert.isNull(implementCheckThreeTreeExistenceComReqDto.getEvaluationTemplateId(), "D3构建部门目标任务书树(公共)-D3-执行三棵树树叶子节点存在性校验(公共)-冗余评价模板ID不能为空", false);
            implementCheckThreeTreeExistenceComRespDto = implementCheckThreeTreeExistenceCom(implementCheckThreeTreeExistenceComReqDto)/*vcase invoke 同服务,同domain*/;


        }
//virtualUsage D2比较入参的部门ID与指标的牵头部门ID是否相同  46750
        ImplementTwoValuesIsEqualityComRespDto implementTwoValuesIsEqualityComRespDto = null;
        if (implementCheckThreeTreeExistenceComRespDto != null) {
            ImplementTwoValuesIsEqualityComReqDto implementTwoValuesIsEqualityComReqDto = new ImplementTwoValuesIsEqualityComReqDto();
            if (reqDto != null) {
                implementTwoValuesIsEqualityComReqDto.setCustomField(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1072772_1_46750
            }
            if (implementCheckThreeTreeExistenceComRespDto != null) {
                implementTwoValuesIsEqualityComReqDto.setCustomField1(implementCheckThreeTreeExistenceComRespDto.getDeptId());//SimpleFieldAssign//sourceId:1072773_1_46750
            }

            /*D2比较入参的部门ID与指标的牵头部门ID是否相同[6425]   */

            implementTwoValuesIsEqualityComRespDto = interfaceModeService.implementTwoValuesIsEqualityCom(implementTwoValuesIsEqualityComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        if ((queryComTargetObjDetailComRespDto != null && queryComTargetObjDetailComRespDto.getRespBodyType() != null && queryComTargetObjDetailComRespDto != null && queryComTargetObjDetailComRespDto.getRespBodyType() != null && queryComTargetObjDetailComRespDto.getRespBodyType().equals("DEPT") && queryComTargetObjDetailComRespDto != null && queryComTargetObjDetailComRespDto.getIsUseFirstDept() != null && queryComTargetObjDetailComRespDto.getIsUseFirstDept().equals("TRUE") && implementCheckThreeTreeExistenceComRespDto != null && implementCheckThreeTreeExistenceComRespDto.getMLevelEvaObjTargetCycleId() == null && implementTwoValuesIsEqualityComRespDto != null && implementTwoValuesIsEqualityComRespDto.getTureOrFalse() != null && implementTwoValuesIsEqualityComRespDto.getTureOrFalse().equals("TRUE"))) {
            //if((D3-查询指标公共详情(公共).责任主体类型 值不等于空  and D3-查询指标公共详情(公共).责任主体类型 等于 部门 and D3-查询指标公共详情(公共).是否用于一级部门 等于 是 and D3-执行三棵树树叶子节点存在性校验(公共).部门目标任务书目标周期ID 值等于空  and D2比较入参的部门ID与指标的牵头部门ID是否相同.是否相等 等于 是))  41167

            List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle = new ArrayList<>();
            QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq = new QueryEvaObjTargetCycleListReq();
            queryEvaObjTargetCycleListReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:926127_1_41168
            queryEvaObjTargetCycleListReq.setEvaObjTableTypeCode("OMS_FRAMEWORK_SPACE");//sourceId:926128_1_41168
            queryEvaObjTargetCycleListReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:926129_1_41168
            queryEvaObjTargetCycleListReq.setTreeTypeCode("EVALUATION_TREE");//sourceId:926130_1_41168
            queryEvaObjTargetCycleListReq.setTargetCycleContentTypeCode("OBJECTIVE");//sourceId:926131_1_41168
            queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:926134_1_41168
            if (reqDto != null) {
                queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:926136_1_41168
                queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:926137_1_41168
            }

            /*3-3-09查被评对象目标周期列表（根据周期时间范围）[2190]   */
            Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjEntityId(), "D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTableTypeCode(), "D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-被评对象内容表类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTypeCode(), "D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-被评对象类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleListReq.getTreeTypeCode(), "D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-树类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentTypeCode(), "D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-关联目标内容类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(), "D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-关联目标内容ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(), "D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(), "D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-是否存档不能为空", false);
            listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;


            boolean bOOLEAN;
            if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle.size() > 0) {
                List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_2 = new ArrayList<>();
                if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)) {
                    listOmsEvaluationObjectTargetCycle_2 = //objList-to-objLists
                            listOmsEvaluationObjectTargetCycle.stream().map(item -> {
                                OmsEvaluationObjectTargetCycle elm = new OmsEvaluationObjectTargetCycle();
                                elm.setEvaObjTargetCycleCode(item.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:198342_2_41169
                                elm.setParentEvaObjTargetCycleId(item.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:198343_2_41169
                                elm.setTargetCycleName(item.getTargetCycleName());//SimpleFieldAssign//sourceId:198375_2_41169
                                elm.setCyclelAlias(item.getCyclelAlias());//SimpleFieldAssign//sourceId:198376_2_41169
                                elm.setEvaObjTableTypeCode("OMS_ORG_DEPT");//sourceId:198346_2_41169
                                elm.setEvaObjTypeCode("FLEVEL_OBJ_TASK_DUTY_DEPT");//sourceId:198347_2_41169
                                elm.setTreeTypeCode("DEP_OBJ_MIS_STA");//sourceId:198344_2_41169
                                elm.setTargetCycleContentTypeCode(item.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:198350_2_41169
                                elm.setTargetCycleContentId(item.getTargetCycleContentId());//SimpleFieldAssign//sourceId:198349_2_41169
                                elm.setIsTarget(item.getIsTarget());//SimpleFieldAssign//sourceId:198351_2_41169
                                elm.setIndicatorKind(item.getIndicatorKind());//SimpleFieldAssign//sourceId:198383_2_41169
                                elm.setIsCustomObjective(item.getIsCustomObjective());//SimpleFieldAssign//sourceId:198384_2_41169
                                elm.setIsUseFirstDept(item.getIsUseFirstDept());//SimpleFieldAssign//sourceId:198372_2_41169
                                elm.setCorrelationLastTargetCatId(item.getCorrelationLastTargetCatId());//SimpleFieldAssign//sourceId:198373_2_41169
                                elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:198355_2_41169
                                elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:198381_2_41169
                                elm.setIsParentCycle(item.getIsParentCycle());//SimpleFieldAssign//sourceId:198352_2_41169
                                elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:198354_2_41169
                                elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:198353_2_41169
                                elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:198368_2_41169
                                elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:198369_2_41169
                                elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:198356_2_41169
                                elm.setCycleTypeInstanceCode(item.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:198357_2_41169
                                elm.setCycleNumberShortName(item.getCycleNumberShortName());//SimpleFieldAssign//sourceId:198377_2_41169
                                elm.setHaveProcessCycle(item.getHaveProcessCycle());//SimpleFieldAssign//sourceId:198385_2_41169
                                elm.setTargetReached(item.getTargetReached());//SimpleFieldAssign//sourceId:198374_2_41169
                                elm.setTaskStatus(item.getTaskStatus());//SimpleFieldAssign//sourceId:198361_2_41169
                                elm.setTotalLength(item.getTotalLength());//SimpleFieldAssign//sourceId:198378_2_41169
                                elm.setDelaySurplusLength(item.getDelaySurplusLength());//SimpleFieldAssign//sourceId:198379_2_41169
                                elm.setDeviateLength(item.getDeviateLength());//SimpleFieldAssign//sourceId:198380_2_41169
                                elm.setBizSceneCode(item.getBizSceneCode());//SimpleFieldAssign//sourceId:198362_2_41169
                                elm.setEvaluationSubjectTypeCode(item.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:198363_2_41169
                                elm.setEvaluationTemplateTypeCode(item.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:198364_2_41169
                                elm.setPlanningType(item.getPlanningType());//SimpleFieldAssign//sourceId:198365_2_41169
                                elm.setTargetId(item.getTargetId());//SimpleFieldAssign//sourceId:198370_2_41169
                                elm.setEvaluationTemplateId(item.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:198366_2_41169
                                elm.setEvaluationSubjectId(item.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:198371_2_41169
                                elm.setReportUpdateTime(item.getReportUpdateTime());//SimpleFieldAssign//sourceId:198358_2_41169
                                elm.setSortCreateTime(item.getSortCreateTime());//SimpleFieldAssign//sourceId:198359_2_41169
                                elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:198360_2_41169
                                elm.setRelativeOrderNumber(item.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:198382_2_41169
                                elm.setBatchCode(item.getBatchCode());//SimpleFieldAssign//sourceId:198367_2_41169
                                if (reqDto != null) {
                                    elm.setEvaObjEntityId(reqDto.getEvaObjEntityId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:198345_2_41169
                                }
                                return elm;
                            }).collect(Collectors.toList());//objList-to-objLists//sourceId:926091_1_41169
                }

                /*3-3-09批量增被评对象目标周期[2494]   */

                bOOLEAN = mOmsEvaluationObjectTargetCycleService.batchAddEvaObjTargetCycle(listOmsEvaluationObjectTargetCycle_2)/*vcase invoke 本地 method 方法调用;*/;


            }
            QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
            QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto = new QueryClassMatchResultToAnswerDetailComReqDto();
            queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("CYCLE_SCHEME_CLASS");//CUSTOM_CONVENTION//sourceId:1072680_1_46752
            queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1072759_1_46752
            if (reqDto != null) {
                queryClassMatchResultToAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1072713_1_46752
            }

            /*D2-3查询配置(周期模式与是否开启中期)[3088]   */
            Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getResultAspObjId(), "D3构建部门目标任务书树(公共)-D2-3查询配置(周期模式与是否开启中期)-开通对象ID不能为空", false);
            Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(), "D3构建部门目标任务书树(公共)-D2-3查询配置(周期模式与是否开启中期)-分组标识不能为空", false);
            Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(), "D3构建部门目标任务书树(公共)-D2-3查询配置(周期模式与是否开启中期)-是否标准答案不能为空", false);
            queryClassMatchResultToAnswerDetailComRespDto = confSchemeService.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            BatchAddTreeLeafWeightSetComRespDto batchAddTreeLeafWeightSetComRespDto = null;
            if (queryClassMatchResultToAnswerDetailComRespDto != null && queryComTargetObjDetailComRespDto != null) {
                BatchAddTreeLeafWeightSetComReqDto batchAddTreeLeafWeightSetComReqDto = new BatchAddTreeLeafWeightSetComReqDto();
                batchAddTreeLeafWeightSetComReqDto.setEvaObjTypeCode("FLEVEL_OBJ_TASK_DUTY_DEPT");//sourceId:1072662_1_46748
                if (reqDto != null) {
                    batchAddTreeLeafWeightSetComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1072661_1_46748
                    batchAddTreeLeafWeightSetComReqDto.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1072663_1_46748
                    batchAddTreeLeafWeightSetComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1072664_1_46748
                }
                if (queryClassMatchResultToAnswerDetailComRespDto != null) {
                    batchAddTreeLeafWeightSetComReqDto.setCycleMode(queryClassMatchResultToAnswerDetailComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1072665_1_46748
                }
                if (queryComTargetObjDetailComRespDto != null) {
                    batchAddTreeLeafWeightSetComReqDto.setBatchCode(queryComTargetObjDetailComRespDto.getBatchCode());//SimpleFieldAssign//sourceId:1168039_1_46748
                }

                /*D3批量增树叶子权重设置(公共)[7150]   */
                Assert.isNull(batchAddTreeLeafWeightSetComReqDto.getEvaObjEntityId(), "D3构建部门目标任务书树(公共)-D3批量增树叶子权重设置(公共)-被评对象内容表主键ID不能为空", false);
                Assert.isNull(batchAddTreeLeafWeightSetComReqDto.getEvaObjTypeCode(), "D3构建部门目标任务书树(公共)-D3批量增树叶子权重设置(公共)-被评对象类型编码不能为空", false);
                Assert.isNull(batchAddTreeLeafWeightSetComReqDto.getTargetCycleContentId(), "D3构建部门目标任务书树(公共)-D3批量增树叶子权重设置(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(batchAddTreeLeafWeightSetComReqDto.getEvaluationTemplateId(), "D3构建部门目标任务书树(公共)-D3批量增树叶子权重设置(公共)-冗余评价模板ID不能为空", false);
                Assert.isNull(batchAddTreeLeafWeightSetComReqDto.getCycleMode(), "D3构建部门目标任务书树(公共)-D3批量增树叶子权重设置(公共)-周期模式不能为空", false);
                Assert.isNull(batchAddTreeLeafWeightSetComReqDto.getBatchCode(), "D3构建部门目标任务书树(公共)-D3批量增树叶子权重设置(公共)-批次标识不能为空", false);
                batchAddTreeLeafWeightSetComRespDto = weightTargetService.batchAddTreeLeafWeightSetCom(batchAddTreeLeafWeightSetComReqDto)/*vcase invoke isSameApp*/;


            }
            GenerateDeptObjTreeLeavesComRespDto generateDeptObjTreeLeavesComRespDto = null;
            if (queryClassMatchResultToAnswerDetailComRespDto != null) {
                GenerateDeptObjTreeLeavesComReqDto generateDeptObjTreeLeavesComReqDto = new GenerateDeptObjTreeLeavesComReqDto();
                generateDeptObjTreeLeavesComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:926092_1_41170
                if (reqDto != null) {
                    generateDeptObjTreeLeavesComReqDto.setEntityId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:926093_1_41170
                }
                if (queryClassMatchResultToAnswerDetailComRespDto != null) {
                    generateDeptObjTreeLeavesComReqDto.setCycleMode(queryClassMatchResultToAnswerDetailComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1072778_1_41170
                    generateDeptObjTreeLeavesComReqDto.setOpenMidCycle(queryClassMatchResultToAnswerDetailComRespDto.getOpenMidCycle());//SimpleFieldAssign//sourceId:1072779_1_41170
                }

                /*D3生成部门目标任务书树叶子(公共)[2332]   */
                Assert.isNull(generateDeptObjTreeLeavesComReqDto.getEntityId(), "D3构建部门目标任务书树(公共)-D3生成部门目标任务书树叶子(公共)-指标ID不能为空", false);
                Assert.isNull(generateDeptObjTreeLeavesComReqDto.getSpaceId(), "D3构建部门目标任务书树(公共)-D3生成部门目标任务书树叶子(公共)-创建于空间ID不能为空", false);
                Assert.isNull(generateDeptObjTreeLeavesComReqDto.getCycleMode(), "D3构建部门目标任务书树(公共)-D3生成部门目标任务书树叶子(公共)-周期模式不能为空", false);
                Assert.isNull(generateDeptObjTreeLeavesComReqDto.getOpenMidCycle(), "D3构建部门目标任务书树(公共)-D3生成部门目标任务书树叶子(公共)-是否开启中期不能为空", false);
                generateDeptObjTreeLeavesComRespDto = timingTaskService.generateDeptObjTreeLeavesCom(generateDeptObjTreeLeavesComReqDto)/*vcase invoke isSameApp*/;


            }
            ImplementCorrectionDeptObjTreeLeavesCodeComRespDto implementCorrectionDeptObjTreeLeavesCodeComRespDto = null;
            if (queryComTargetObjDetailComRespDto != null) {
                ImplementCorrectionDeptObjTreeLeavesCodeComReqDto implementCorrectionDeptObjTreeLeavesCodeComReqDto = new ImplementCorrectionDeptObjTreeLeavesCodeComReqDto();
                if (reqDto != null) {
                    implementCorrectionDeptObjTreeLeavesCodeComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:926098_1_41171
                    implementCorrectionDeptObjTreeLeavesCodeComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:926099_1_41171
                    implementCorrectionDeptObjTreeLeavesCodeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:926094_1_41171
                }
                if (queryComTargetObjDetailComRespDto != null) {
                    implementCorrectionDeptObjTreeLeavesCodeComReqDto.setParentObjectiveId(queryComTargetObjDetailComRespDto.getParentObjectiveId());//SimpleFieldAssign//sourceId:926097_1_41171
                    implementCorrectionDeptObjTreeLeavesCodeComReqDto.setCorrelationLastTargetCatId(queryComTargetObjDetailComRespDto.getCorrelationLastTargetCatId());//SimpleFieldAssign//sourceId:926096_1_41171
                    implementCorrectionDeptObjTreeLeavesCodeComReqDto.setLevelNumber(queryComTargetObjDetailComRespDto.getLevelNumber());//SimpleFieldAssign//sourceId:926095_1_41171
                }

                /*D3执行修正部门目标任务书树叶子标识(公共)[5940]   */
                Assert.isNull(implementCorrectionDeptObjTreeLeavesCodeComReqDto.getEvaObjEntityId(), "D3构建部门目标任务书树(公共)-D3执行修正部门目标任务书树叶子标识(公共)-被评对象内容表主键ID不能为空", false);
                Assert.isNull(implementCorrectionDeptObjTreeLeavesCodeComReqDto.getObjectiveId(), "D3构建部门目标任务书树(公共)-D3执行修正部门目标任务书树叶子标识(公共)-指标ID不能为空", false);
                Assert.isNull(implementCorrectionDeptObjTreeLeavesCodeComReqDto.getCorrelationLastTargetCatId(), "D3构建部门目标任务书树(公共)-D3执行修正部门目标任务书树叶子标识(公共)-关联末级目标分类ID不能为空", false);
                Assert.isNull(implementCorrectionDeptObjTreeLeavesCodeComReqDto.getLevelNumber(), "D3构建部门目标任务书树(公共)-D3执行修正部门目标任务书树叶子标识(公共)-层级不能为空", false);
                Assert.isNull(implementCorrectionDeptObjTreeLeavesCodeComReqDto.getEvaluationTemplateId(), "D3构建部门目标任务书树(公共)-D3执行修正部门目标任务书树叶子标识(公共)-冗余评价模板ID不能为空", false);
                implementCorrectionDeptObjTreeLeavesCodeComRespDto = targetCycleService.implementCorrectionDeptObjTreeLeavesCodeCom(implementCorrectionDeptObjTreeLeavesCodeComReqDto)/*vcase invoke isSameApp*/;


            }
            ImplementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComRespDto implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComRespDto = null;
            ImplementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto = new ImplementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto();
            if (reqDto != null) {
                implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1072775_1_46751
                implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1072776_1_46751
                implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1072777_1_46751
            }

            /*D3初始化部门目标任务书当前叶子父子状态(公共)[7213]   */
            Assert.isNull(implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto.getEvaObjEntityId(), "D3构建部门目标任务书树(公共)-D3初始化部门目标任务书当前叶子父子状态(公共)-被评对象内容表主键ID不能为空", false);
            Assert.isNull(implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto.getTargetCycleContentId(), "D3构建部门目标任务书树(公共)-D3初始化部门目标任务书当前叶子父子状态(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto.getEvaluationTemplateId(), "D3构建部门目标任务书树(公共)-D3初始化部门目标任务书当前叶子父子状态(公共)-冗余评价模板ID不能为空", false);
            implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComRespDto = offStateService.implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeCom(implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto)/*vcase invoke isSameApp*/;


        }
        ImplementCreateFlevelObjTaskTreeDeptComRespDto retData = new ImplementCreateFlevelObjTaskTreeDeptComRespDto();


        return retData;
    }
    //
}
